home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / db.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  61.9 KB  |  1,546 lines
  1. // Borland C++ Builder
  2. // Copyright (c) 1995, 1998 by Borland International
  3. // All rights reserved
  4.  
  5. // (DO NOT EDIT: machine generated header) 'Db.pas' rev: 3.00
  6.  
  7. #ifndef DbHPP
  8. #define DbHPP
  9. #include <Graphics.hpp>
  10. #include <Classes.hpp>
  11. #include <SysUtils.hpp>
  12. #include <Windows.hpp>
  13. #include <SysInit.hpp>
  14. #include <System.hpp>
  15.  
  16. //-- user supplied -----------------------------------------------------------
  17. namespace Db
  18. {
  19.     typedef TDateTimeBase TDateTimeAlias;
  20. }
  21.  
  22. namespace Db
  23. {
  24. //-- type declarations -------------------------------------------------------
  25. enum TDataSetState { dsInactive, dsBrowse, dsEdit, dsInsert, dsSetKey, dsCalcFields, dsFilter, dsNewValue, 
  26.     dsOldValue, dsCurValue };
  27.  
  28. enum TDataEvent { deFieldChange, deRecordChange, deDataSetChange, deDataSetScroll, deLayoutChange, deUpdateRecord, 
  29.     deUpdateState, deCheckBrowseMode, dePropertyChange, deFieldListChange, deFocusControl };
  30.  
  31. enum TUpdateStatus { usUnmodified, usModified, usInserted, usDeleted };
  32.  
  33. class DELPHICLASS EDatabaseError;
  34. class PASCALIMPLEMENTATION EDatabaseError : public Sysutils::Exception 
  35. {
  36.     typedef Sysutils::Exception inherited;
  37.     
  38. public:
  39.     /* Exception.Create */ __fastcall EDatabaseError(const System::AnsiString Msg) : Sysutils::Exception(
  40.         Msg) { }
  41.     /* Exception.CreateFmt */ __fastcall EDatabaseError(const System::AnsiString Msg, const System::TVarRec 
  42.         * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
  43.     /* Exception.CreateRes */ __fastcall EDatabaseError(int Ident, Extended Dummy) : Sysutils::Exception(
  44.         Ident, Dummy) { }
  45.     /* Exception.CreateResFmt */ __fastcall EDatabaseError(int Ident, const System::TVarRec * Args, const 
  46.         int Args_Size) : Sysutils::Exception(Ident, Args, Args_Size) { }
  47.     /* Exception.CreateHelp */ __fastcall EDatabaseError(const System::AnsiString Msg, int AHelpContext
  48.         ) : Sysutils::Exception(Msg, AHelpContext) { }
  49.     /* Exception.CreateFmtHelp */ __fastcall EDatabaseError(const System::AnsiString Msg, const System::TVarRec 
  50.         * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size, AHelpContext
  51.         ) { }
  52.     /* Exception.CreateResHelp */ __fastcall EDatabaseError(int Ident, int AHelpContext) : Sysutils::Exception(
  53.         Ident, AHelpContext) { }
  54.     /* Exception.CreateResFmtHelp */ __fastcall EDatabaseError(int Ident, const System::TVarRec * Args, 
  55.         const int Args_Size, int AHelpContext) : Sysutils::Exception(Ident, Args, Args_Size, AHelpContext)
  56.          { }
  57.     
  58. public:
  59.     /* TObject.Destroy */ __fastcall virtual ~EDatabaseError(void) { }
  60.     
  61. };
  62.  
  63. class DELPHICLASS TNamedItem;
  64. class PASCALIMPLEMENTATION TNamedItem : public Classes::TCollectionItem 
  65. {
  66.     typedef Classes::TCollectionItem inherited;
  67.     
  68. private:
  69.     System::AnsiString FName;
  70.     
  71. protected:
  72.     virtual System::AnsiString __fastcall GetDisplayName(void);
  73.     virtual void __fastcall SetDisplayName(const System::AnsiString Value);
  74.     
  75. __published:
  76.     __property System::AnsiString Name = {read=FName, write=SetDisplayName};
  77. public:
  78.     /* TCollectionItem.Create */ __fastcall virtual TNamedItem(Classes::TCollection* Collection) : Classes::
  79.         TCollectionItem(Collection) { }
  80.     /* TCollectionItem.Destroy */ __fastcall virtual ~TNamedItem(void) { }
  81.     
  82. };
  83.  
  84. typedef void __fastcall (__closure *TDefUpdateMethod)(void);
  85.  
  86. class DELPHICLASS TDefCollection;
  87. class DELPHICLASS TDataSet;
  88. class DELPHICLASS TFieldDefs;
  89. class PASCALIMPLEMENTATION TDefCollection : public Classes::TCollection 
  90. {
  91.     typedef Classes::TCollection inherited;
  92.     
  93. private:
  94.     TDataSet* FDataset;
  95.     bool FUpdated;
  96.     
  97. protected:
  98.     DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
  99.     virtual void __fastcall SetItemName(Classes::TCollectionItem* AItem);
  100.     virtual void __fastcall Update(Classes::TCollectionItem* AItem);
  101.     void __fastcall UpdateDefs(TDefUpdateMethod AMethod);
  102.     
  103. public:
  104.     __fastcall TDefCollection(TDataSet* ADataset, System::TMetaClass* AClass);
  105.     int __fastcall IndexOf(const System::AnsiString AName);
  106.     TNamedItem* __fastcall Find(const System::AnsiString AName);
  107.     __property TDataSet* Dataset = {read=FDataset};
  108.     __property bool Updated = {read=FUpdated, write=FUpdated, nodefault};
  109. public:
  110.     /* TCollection.Destroy */ __fastcall virtual ~TDefCollection(void) { }
  111.     
  112. };
  113.  
  114. class DELPHICLASS TFieldDef;
  115. enum TFieldType { ftUnknown, ftString, ftSmallint, ftInteger, ftWord, ftBoolean, ftFloat, ftCurrency, 
  116.     ftBCD, ftDate, ftTime, ftDateTime, ftBytes, ftVarBytes, ftAutoInc, ftBlob, ftMemo, ftGraphic, ftFmtMemo, 
  117.     ftParadoxOle, ftDBaseOle, ftTypedBinary, ftCursor };
  118.  
  119. class PASCALIMPLEMENTATION TFieldDefs : public Db::TDefCollection 
  120. {
  121.     typedef Db::TDefCollection inherited;
  122.     
  123. private:
  124.     TFieldDef* __fastcall GetFieldDef(int Index);
  125.     void __fastcall SetFieldDef(int Index, TFieldDef* Value);
  126.     
  127. public:
  128.     __fastcall TFieldDefs(TDataSet* ADataset);
  129.     TFieldDef* __fastcall AddFieldDef(void);
  130.     HIDESBASE TFieldDef* __fastcall Find(const System::AnsiString Name);
  131.     HIDESBASE void __fastcall Update(void);
  132.     HIDESBASE void __fastcall Add(const System::AnsiString N, TFieldType T, Word S, bool R);
  133.     __property TFieldDef* Items[int Index] = {read=GetFieldDef, write=SetFieldDef/*, default*/};
  134. public:
  135.         
  136.     /* TCollection.Destroy */ __fastcall virtual ~TFieldDefs(void) { }
  137.     
  138. };
  139.  
  140. class DELPHICLASS TDataLink;
  141. class DELPHICLASS TDataSource;
  142. class DELPHICLASS TField;
  143. typedef void __fastcall (__closure *TDataChangeEvent)(System::TObject* Sender, TField* Field);
  144.  
  145. class PASCALIMPLEMENTATION TDataSource : public Classes::TComponent 
  146. {
  147.     typedef Classes::TComponent inherited;
  148.     
  149. private:
  150.     TDataSet* FDataSet;
  151.     Classes::TList* FDataLinks;
  152.     bool FEnabled;
  153.     bool FAutoEdit;
  154.     TDataSetState FState;
  155.     Classes::TNotifyEvent FOnStateChange;
  156.     TDataChangeEvent FOnDataChange;
  157.     Classes::TNotifyEvent FOnUpdateData;
  158.     void __fastcall AddDataLink(TDataLink* DataLink);
  159.     void __fastcall DataEvent(TDataEvent Event, int Info);
  160.     void __fastcall NotifyDataLinks(TDataEvent Event, int Info);
  161.     void __fastcall RemoveDataLink(TDataLink* DataLink);
  162.     void __fastcall SetDataSet(TDataSet* ADataSet);
  163.     void __fastcall SetEnabled(bool Value);
  164.     void __fastcall SetState(TDataSetState Value);
  165.     void __fastcall UpdateState(void);
  166.     
  167. protected:
  168.     __property Classes::TList* DataLinks = {read=FDataLinks};
  169.     
  170. public:
  171.     __fastcall virtual TDataSource(Classes::TComponent* AOwner);
  172.     __fastcall virtual ~TDataSource(void);
  173.     void __fastcall Edit(void);
  174.     bool __fastcall IsLinkedTo(TDataSet* DataSet);
  175.     __property TDataSetState State = {read=FState, nodefault};
  176.     
  177. __published:
  178.     __property bool AutoEdit = {read=FAutoEdit, write=FAutoEdit, default=1};
  179.     __property TDataSet* DataSet = {read=FDataSet, write=SetDataSet};
  180.     __property bool Enabled = {read=FEnabled, write=SetEnabled, default=1};
  181.     __property Classes::TNotifyEvent OnStateChange = {read=FOnStateChange, write=FOnStateChange};
  182.     __property TDataChangeEvent OnDataChange = {read=FOnDataChange, write=FOnDataChange};
  183.     __property Classes::TNotifyEvent OnUpdateData = {read=FOnUpdateData, write=FOnUpdateData};
  184. };
  185.  
  186. typedef TField* *TFieldRef;
  187.  
  188. class PASCALIMPLEMENTATION TDataLink : public Classes::TPersistent 
  189. {
  190.     typedef Classes::TPersistent inherited;
  191.     
  192. private:
  193.     TDataSource* FDataSource;
  194.     TDataLink* FNext;
  195.     int FBufferCount;
  196.     int FFirstRecord;
  197.     bool FReadOnly;
  198.     bool FActive;
  199.     bool FEditing;
  200.     bool FUpdating;
  201.     bool FDataSourceFixed;
  202.     void __fastcall DataEvent(TDataEvent Event, int Info);
  203.     int __fastcall GetActiveRecord(void);
  204.     TDataSet* __fastcall GetDataSet(void);
  205.     int __fastcall GetRecordCount(void);
  206.     void __fastcall SetActive(bool Value);
  207.     void __fastcall SetActiveRecord(int Value);
  208.     void __fastcall SetBufferCount(int Value);
  209.     void __fastcall SetDataSource(TDataSource* ADataSource);
  210.     void __fastcall SetEditing(bool Value);
  211.     void __fastcall SetReadOnly(bool Value);
  212.     void __fastcall UpdateRange(void);
  213.     void __fastcall UpdateState(void);
  214.     
  215. protected:
  216.     virtual void __fastcall ActiveChanged(void);
  217.     virtual void __fastcall CheckBrowseMode(void);
  218.     virtual void __fastcall DataSetChanged(void);
  219.     virtual void __fastcall DataSetScrolled(int Distance);
  220.     virtual void __fastcall FocusControl(TFieldRef Field);
  221.     virtual void __fastcall EditingChanged(void);
  222.     virtual void __fastcall LayoutChanged(void);
  223.     virtual void __fastcall RecordChanged(TField* Field);
  224.     virtual void __fastcall UpdateData(void);
  225.     
  226. public:
  227.     __fastcall TDataLink(void);
  228.     __fastcall virtual ~TDataLink(void);
  229.     bool __fastcall Edit(void);
  230.     void __fastcall UpdateRecord(void);
  231.     __property bool Active = {read=FActive, nodefault};
  232.     __property int ActiveRecord = {read=GetActiveRecord, write=SetActiveRecord, nodefault};
  233.     __property int BufferCount = {read=FBufferCount, write=SetBufferCount, nodefault};
  234.     __property TDataSet* DataSet = {read=GetDataSet};
  235.     __property TDataSource* DataSource = {read=FDataSource, write=SetDataSource};
  236.     __property bool DataSourceFixed = {read=FDataSourceFixed, write=FDataSourceFixed, nodefault};
  237.     __property bool Editing = {read=FEditing, nodefault};
  238.     __property bool ReadOnly = {read=FReadOnly, write=SetReadOnly, nodefault};
  239.     __property int RecordCount = {read=GetRecordCount, nodefault};
  240. };
  241.  
  242. typedef char *TBufferList[268435455];
  243.  
  244. typedef TBufferList *PBufferList;
  245.  
  246. class DELPHICLASS TDataSetDesigner;
  247. class PASCALIMPLEMENTATION TDataSetDesigner : public System::TObject 
  248. {
  249.     typedef System::TObject inherited;
  250.     
  251. private:
  252.     TDataSet* FDataSet;
  253.     bool FSaveActive;
  254.     
  255. public:
  256.     __fastcall TDataSetDesigner(TDataSet* DataSet);
  257.     __fastcall virtual ~TDataSetDesigner(void);
  258.     void __fastcall BeginDesign(void);
  259.     virtual void __fastcall DataEvent(TDataEvent Event, int Info);
  260.     void __fastcall EndDesign(void);
  261.     __property TDataSet* DataSet = {read=FDataSet};
  262. };
  263.  
  264. enum TFilterOption { foCaseInsensitive, foNoPartialCompare };
  265.  
  266. typedef Set<TFilterOption, foCaseInsensitive, foNoPartialCompare>  TFilterOptions;
  267.  
  268. class DELPHICLASS TCheckConstraints;
  269. class DELPHICLASS TCheckConstraint;
  270. class PASCALIMPLEMENTATION TCheckConstraints : public Classes::TCollection 
  271. {
  272.     typedef Classes::TCollection inherited;
  273.     
  274. private:
  275.     Classes::TPersistent* FOwner;
  276.     HIDESBASE TCheckConstraint* __fastcall GetItem(int Index);
  277.     HIDESBASE void __fastcall SetItem(int Index, TCheckConstraint* Value);
  278.     
  279. protected:
  280.     DYNAMIC Classes::TPersistent* __fastcall GetOwner(void);
  281.     
  282. public:
  283.     __fastcall TCheckConstraints(Classes::TPersistent* Owner);
  284.     HIDESBASE TCheckConstraint* __fastcall Add(void);
  285.     __property TCheckConstraint* Items[int Index] = {read=GetItem, write=SetItem/*, default*/};
  286. public:
  287.     /* TCollection.Destroy */ __fastcall virtual ~TCheckConstraints(void) { }
  288.     
  289. };
  290.  
  291. typedef void __fastcall (__closure *TDataSetNotifyEvent)(TDataSet* DataSet);
  292.  
  293. enum TDataAction { daFail, daAbort, daRetry };
  294.  
  295. typedef void __fastcall (__closure *TDataSetErrorEvent)(TDataSet* DataSet, EDatabaseError* E, TDataAction 
  296.     &Action);
  297.  
  298. typedef void __fastcall (__closure *TFilterRecordEvent)(TDataSet* DataSet, bool &Accept);
  299.  
  300. typedef void __fastcall (__closure *TDataOperation)(void);
  301.  
  302. typedef System::TMetaClass*TFieldClass;
  303.  
  304. enum TBookmarkFlag { bfCurrent, bfBOF, bfEOF, bfInserted };
  305.  
  306. enum TGetResult { grOK, grBOF, grEOF, grError };
  307.  
  308. enum TGetMode { gmCurrent, gmNext, gmPrior };
  309.  
  310. enum TBlobStreamMode { bmRead, bmWrite, bmReadWrite };
  311.  
  312. enum TLocateOption { loCaseInsensitive, loPartialKey };
  313.  
  314. typedef Set<TLocateOption, loCaseInsensitive, loPartialKey>  TLocateOptions;
  315.  
  316. enum Db__63 { rmExact, rmCenter };
  317.  
  318. typedef Set<Db__63, rmExact, rmCenter>  TResyncMode;
  319.  
  320. class PASCALIMPLEMENTATION TDataSet : public Classes::TComponent 
  321. {
  322.     typedef Classes::TComponent inherited;
  323.     
  324. private:
  325.     Classes::TList* FFields;
  326.     TFieldDefs* FFieldDefs;
  327.     Classes::TList* FDataSources;
  328.     TDataLink* FFirstDataLink;
  329.     int FBufferCount;
  330.     int FRecordCount;
  331.     int FActiveRecord;
  332.     int FCurrentRecord;
  333.     TBufferList *FBuffers;
  334.     char *FCalcBuffer;
  335.     int FBufListSize;
  336.     int FBookmarkSize;
  337.     int FCalcFieldsSize;
  338.     bool FBOF;
  339.     bool FEOF;
  340.     bool FModified;
  341.     bool FStreamedActive;
  342.     bool FInternalCalcFields;
  343.     TDataSetState FState;
  344.     TDataEvent FEnableEvent;
  345.     TDataSetState FDisableState;
  346.     TDataSetDesigner* FDesigner;
  347.     int FDisableCount;
  348.     bool FFound;
  349.     bool FDefaultFields;
  350.     bool FAutoCalcFields;
  351.     bool FFiltered;
  352.     int FBlobFieldCount;
  353.     System::AnsiString FFilterText;
  354.     TFilterOptions FFilterOptions;
  355.     TCheckConstraints* FConstraints;
  356.     TDataSetNotifyEvent FBeforeOpen;
  357.     TDataSetNotifyEvent FAfterOpen;
  358.     TDataSetNotifyEvent FBeforeClose;
  359.     TDataSetNotifyEvent FAfterClose;
  360.     TDataSetNotifyEvent FBeforeInsert;
  361.     TDataSetNotifyEvent FAfterInsert;
  362.     TDataSetNotifyEvent FBeforeEdit;
  363.     TDataSetNotifyEvent FAfterEdit;
  364.     TDataSetNotifyEvent FBeforePost;
  365.     TDataSetNotifyEvent FAfterPost;
  366.     TDataSetNotifyEvent FBeforeCancel;
  367.     TDataSetNotifyEvent FAfterCancel;
  368.     TDataSetNotifyEvent FBeforeDelete;
  369.     TDataSetNotifyEvent FAfterDelete;
  370.     TDataSetNotifyEvent FBeforeScroll;
  371.     TDataSetNotifyEvent FAfterScroll;
  372.     TDataSetNotifyEvent FOnNewRecord;
  373.     TDataSetNotifyEvent FOnCalcFields;
  374.     TDataSetErrorEvent FOnEditError;
  375.     TDataSetErrorEvent FOnPostError;
  376.     TDataSetErrorEvent FOnDeleteError;
  377.     TFilterRecordEvent FOnFilterRecord;
  378.     void __fastcall AddDataSource(TDataSource* DataSource);
  379.     void __fastcall AddField(TField* Field);
  380.     void __fastcall AddRecord(const System::TVarRec * Values, const int Values_Size, bool Append);
  381.     void __fastcall BeginInsertAppend(void);
  382.     void __fastcall CheckCanModify(void);
  383.     void __fastcall CheckFieldName(const System::AnsiString FieldName);
  384.     void __fastcall CheckFieldNames(const System::AnsiString FieldNames);
  385.     void __fastcall CheckOperation(TDataOperation Operation, TDataSetErrorEvent ErrorEvent);
  386.     void __fastcall CheckRequiredFields(void);
  387.     void __fastcall DoInternalOpen(void);
  388.     void __fastcall DoInternalClose(void);
  389.     void __fastcall EndInsertAppend(void);
  390.     bool __fastcall GetActive(void);
  391.     char * __fastcall GetBuffer(int Index);
  392.     TField* __fastcall GetField(int Index);
  393.     int __fastcall GetFieldCount(void);
  394.     System::Variant __fastcall GetFieldValue(const System::AnsiString FieldName);
  395.     bool __fastcall GetFound(void);
  396.     void __fastcall MoveBuffer(int CurIndex, int NewIndex);
  397.     void __fastcall RemoveDataSource(TDataSource* DataSource);
  398.     void __fastcall RemoveField(TField* Field);
  399.     void __fastcall SetActive(bool Value);
  400.     void __fastcall SetBufferCount(int Value);
  401.     void __fastcall SetField(int Index, TField* Value);
  402.     void __fastcall SetFieldDefs(TFieldDefs* Value);
  403.     void __fastcall SetFieldValue(const System::AnsiString FieldName, const System::Variant &Value);
  404.     void __fastcall SetConstraints(TCheckConstraints* Value);
  405.     void __fastcall UpdateBufferCount(void);
  406.     
  407. protected:
  408.     virtual void __fastcall ActivateBuffers(void);
  409.     void __fastcall BindFields(bool Binding);
  410.     bool __fastcall BookmarkAvailable(void);
  411.     virtual bool __fastcall BCDToCurr(void * BCD, System::Currency &Curr);
  412.     virtual bool __fastcall CurrToBCD(const System::Currency Curr, void * BCD, int Precision, int Decimals
  413.         );
  414.     virtual void __fastcall CalculateFields(char * Buffer);
  415.     virtual void __fastcall CheckActive(void);
  416.     virtual void __fastcall CheckInactive(void);
  417.     virtual void __fastcall ClearBuffers(void);
  418.     virtual void __fastcall ClearCalcFields(char * Buffer);
  419.     virtual void __fastcall CloseBlob(TField* Field);
  420.     virtual void __fastcall CloseCursor(void);
  421.     void __fastcall CreateFields(void);
  422.     virtual void __fastcall DataEvent(TDataEvent Event, int Info);
  423.     virtual void __fastcall DefChanged(System::TObject* Sender);
  424.     virtual void __fastcall DestroyFields(void);
  425.     virtual void __fastcall DoAfterCancel(void);
  426.     virtual void __fastcall DoAfterClose(void);
  427.     virtual void __fastcall DoAfterDelete(void);
  428.     virtual void __fastcall DoAfterEdit(void);
  429.     virtual void __fastcall DoAfterInsert(void);
  430.     virtual void __fastcall DoAfterOpen(void);
  431.     virtual void __fastcall DoAfterPost(void);
  432.     virtual void __fastcall DoAfterScroll(void);
  433.     virtual void __fastcall DoBeforeCancel(void);
  434.     virtual void __fastcall DoBeforeClose(void);
  435.     virtual void __fastcall DoBeforeDelete(void);
  436.     virtual void __fastcall DoBeforeEdit(void);
  437.     virtual void __fastcall DoBeforeInsert(void);
  438.     virtual void __fastcall DoBeforeOpen(void);
  439.     virtual void __fastcall DoBeforePost(void);
  440.     virtual void __fastcall DoBeforeScroll(void);
  441.     virtual void __fastcall DoOnCalcFields(void);
  442.     virtual void __fastcall DoOnNewRecord(void);
  443.     TField* __fastcall FieldByNumber(int FieldNo);
  444.     virtual bool __fastcall FindRecord(bool Restart, bool GoForward);
  445.     virtual void __fastcall FreeFieldBuffers(void);
  446.     virtual System::AnsiString __fastcall GetBookmarkStr(void);
  447.     virtual void __fastcall GetCalcFields(char * Buffer);
  448.     virtual bool __fastcall GetCanModify(void);
  449.     DYNAMIC void __fastcall GetChildren(Classes::TGetChildProc Proc, Classes::TComponent* Root);
  450.     virtual TDataSource* __fastcall GetDataSource(void);
  451.     virtual System::TMetaClass* __fastcall GetFieldClass(TFieldType FieldType);
  452.     virtual System::Variant __fastcall GetStateFieldValue(TDataSetState State, TField* Field);
  453.     virtual bool __fastcall GetIsIndexField(TField* Field);
  454.     virtual int __fastcall GetNextRecords(void);
  455.     virtual bool __fastcall GetNextRecord(void);
  456.     virtual int __fastcall GetPriorRecords(void);
  457.     virtual bool __fastcall GetPriorRecord(void);
  458.     virtual int __fastcall GetRecordCount(void);
  459.     virtual int __fastcall GetRecNo(void);
  460.     virtual void __fastcall InitFieldDefs(void);
  461.     virtual void __fastcall InitRecord(char * Buffer);
  462.     virtual void __fastcall InternalCancel(void);
  463.     virtual void __fastcall InternalEdit(void);
  464.     virtual void __fastcall InternalRefresh(void);
  465.     virtual void __fastcall Loaded(void);
  466.     virtual void __fastcall OpenCursor(bool InfoQuery);
  467.     virtual void __fastcall RefreshInternalCalcFields(char * Buffer);
  468.     void __fastcall RestoreState(const TDataSetState Value);
  469.     virtual void __fastcall SetBookmarkStr(const System::AnsiString Value);
  470.     void __fastcall SetBufListSize(int Value);
  471.     DYNAMIC void __fastcall SetChildOrder(Classes::TComponent* Component, int Order);
  472.     virtual void __fastcall SetCurrentRecord(int Index);
  473.     virtual void __fastcall SetFiltered(bool Value);
  474.     virtual void __fastcall SetFilterOptions(TFilterOptions Value);
  475.     virtual void __fastcall SetFilterText(const System::AnsiString Value);
  476.     void __fastcall SetFound(const bool Value);
  477.     void __fastcall SetModified(bool Value);
  478.     virtual void __fastcall SetName(const System::AnsiString Value);
  479.     virtual void __fastcall SetStateFieldValue(TDataSetState State, TField* Field, const System::Variant 
  480.         &Value);
  481.     virtual void __fastcall SetOnFilterRecord(const TFilterRecordEvent Value);
  482.     virtual void __fastcall SetRecNo(int Value);
  483.     void __fastcall SetState(TDataSetState Value);
  484.     TDataSetState __fastcall SetTempState(const TDataSetState Value);
  485.     char * __fastcall TempBuffer(void);
  486.     virtual void __fastcall UpdateIndexDefs(void);
  487.     __property int ActiveRecord = {read=FActiveRecord, nodefault};
  488.     __property int CurrentRecord = {read=FCurrentRecord, nodefault};
  489.     __property int BlobFieldCount = {read=FBlobFieldCount, nodefault};
  490.     __property int BookmarkSize = {read=FBookmarkSize, write=FBookmarkSize, nodefault};
  491.     __property char * Buffers[int Index] = {read=GetBuffer};
  492.     __property int BufferCount = {read=FBufferCount, nodefault};
  493.     __property char * CalcBuffer = {read=FCalcBuffer};
  494.     __property int CalcFieldsSize = {read=FCalcFieldsSize, nodefault};
  495.     __property bool InternalCalcFields = {read=FInternalCalcFields, nodefault};
  496.     __property TCheckConstraints* Constraints = {read=FConstraints, write=SetConstraints};
  497.     virtual char * __fastcall AllocRecordBuffer(void) = 0;
  498.     virtual void __fastcall FreeRecordBuffer(char * &Buffer) = 0;
  499.     virtual void __fastcall GetBookmarkData(char * Buffer, void * Data) = 0;
  500.     virtual TBookmarkFlag __fastcall GetBookmarkFlag(char * Buffer) = 0;
  501.     virtual bool __fastcall GetFieldData(TField* Field, void * Buffer) = 0;
  502.     virtual TGetResult __fastcall GetRecord(char * Buffer, TGetMode GetMode, bool DoCheck) = 0;
  503.     virtual Word __fastcall GetRecordSize(void) = 0;
  504.     virtual void __fastcall InternalAddRecord(void * Buffer, bool Append) = 0;
  505.     virtual void __fastcall InternalClose(void) = 0;
  506.     virtual void __fastcall InternalDelete(void) = 0;
  507.     virtual void __fastcall InternalFirst(void) = 0;
  508.     virtual void __fastcall InternalGotoBookmark(void * Bookmark) = 0;
  509.     virtual void __fastcall InternalHandleException(void) = 0;
  510.     virtual void __fastcall InternalInitFieldDefs(void) = 0;
  511.     virtual void __fastcall InternalInitRecord(char * Buffer) = 0;
  512.     virtual void __fastcall InternalLast(void) = 0;
  513.     virtual void __fastcall InternalOpen(void) = 0;
  514.     virtual void __fastcall InternalPost(void) = 0;
  515.     virtual void __fastcall InternalSetToRecord(char * Buffer) = 0;
  516.     virtual bool __fastcall IsCursorOpen(void) = 0;
  517.     virtual void __fastcall SetBookmarkFlag(char * Buffer, TBookmarkFlag Value) = 0;
  518.     virtual void __fastcall SetBookmarkData(char * Buffer, void * Data) = 0;
  519.     virtual void __fastcall SetFieldData(TField* Field, void * Buffer) = 0;
  520.     
  521. public:
  522.     __fastcall virtual TDataSet(Classes::TComponent* AOwner);
  523.     __fastcall virtual ~TDataSet(void);
  524.     char * __fastcall ActiveBuffer(void);
  525.     void __fastcall Append(void);
  526.     void __fastcall AppendRecord(const System::TVarRec * Values, const int Values_Size);
  527.     virtual bool __fastcall BookmarkValid(void * Bookmark);
  528.     virtual void __fastcall Cancel(void);
  529.     void __fastcall CheckBrowseMode(void);
  530.     void __fastcall ClearFields(void);
  531.     void __fastcall Close(void);
  532.     bool __fastcall ControlsDisabled(void);
  533.     virtual int __fastcall CompareBookmarks(void * Bookmark1, void * Bookmark2);
  534.     virtual Classes::TStream* __fastcall CreateBlobStream(TField* Field, TBlobStreamMode Mode);
  535.     void __fastcall CursorPosChanged(void);
  536.     void __fastcall Delete(void);
  537.     void __fastcall DisableControls(void);
  538.     void __fastcall Edit(void);
  539.     void __fastcall EnableControls(void);
  540.     TField* __fastcall FieldByName(const System::AnsiString FieldName);
  541.     TField* __fastcall FindField(const System::AnsiString FieldName);
  542.     bool __fastcall FindFirst(void);
  543.     bool __fastcall FindLast(void);
  544.     bool __fastcall FindNext(void);
  545.     bool __fastcall FindPrior(void);
  546.     void __fastcall First(void);
  547.     virtual void __fastcall FreeBookmark(void * Bookmark);
  548.     virtual void * __fastcall GetBookmark(void);
  549.     virtual bool __fastcall GetCurrentRecord(char * Buffer);
  550.     void __fastcall GetFieldList(Classes::TList* List, const System::AnsiString FieldNames);
  551.     void __fastcall GetFieldNames(Classes::TStrings* List);
  552.     void __fastcall GotoBookmark(void * Bookmark);
  553.     HIDESBASE void __fastcall Insert(void);
  554.     void __fastcall InsertRecord(const System::TVarRec * Values, const int Values_Size);
  555.     bool __fastcall IsEmpty(void);
  556.     bool __fastcall IsLinkedTo(TDataSource* DataSource);
  557.     virtual bool __fastcall IsSequenced(void);
  558.     void __fastcall Last(void);
  559.     virtual bool __fastcall Locate(const System::AnsiString KeyFields, const System::Variant &KeyValues
  560.         , TLocateOptions Options);
  561.     virtual System::Variant __fastcall Lookup(const System::AnsiString KeyFields, const System::Variant 
  562.         &KeyValues, const System::AnsiString ResultFields);
  563.     int __fastcall MoveBy(int Distance);
  564.     void __fastcall Next(void);
  565.     void __fastcall Open(void);
  566.     virtual void __fastcall Post(void);
  567.     void __fastcall Prior(void);
  568.     void __fastcall Refresh(void);
  569.     virtual void __fastcall Resync(TResyncMode Mode);
  570.     void __fastcall SetFields(const System::TVarRec * Values, const int Values_Size);
  571.     virtual void __fastcall Translate(char * Src, char * Dest, bool ToOem);
  572.     void __fastcall UpdateCursorPos(void);
  573.     void __fastcall UpdateRecord(void);
  574.     __property bool Bof = {read=FBOF, nodefault};
  575.     __property System::AnsiString Bookmark = {read=GetBookmarkStr, write=SetBookmarkStr};
  576.     __property bool CanModify = {read=GetCanModify, nodefault};
  577.     __property TDataSource* DataSource = {read=GetDataSource};
  578.     __property bool DefaultFields = {read=FDefaultFields, nodefault};
  579.     __property TDataSetDesigner* Designer = {read=FDesigner};
  580.     __property bool Eof = {read=FEOF, nodefault};
  581.     __property int FieldCount = {read=GetFieldCount, nodefault};
  582.     __property TFieldDefs* FieldDefs = {read=FFieldDefs, write=SetFieldDefs};
  583.     __property TField* Fields[int Index] = {read=GetField, write=SetField};
  584.     __property System::Variant FieldValues[System::AnsiString FieldName] = {read=GetFieldValue, write=SetFieldValue
  585.         /*, default*/};
  586.     __property bool Found = {read=GetFound, nodefault};
  587.     __property bool Modified = {read=FModified, nodefault};
  588.     __property int RecordCount = {read=GetRecordCount, nodefault};
  589.     __property int RecNo = {read=GetRecNo, write=SetRecNo, nodefault};
  590.     __property Word RecordSize = {read=GetRecordSize, nodefault};
  591.     __property TDataSetState State = {read=FState, nodefault};
  592.     __property System::AnsiString Filter = {read=FFilterText, write=SetFilterText};
  593.     __property bool Filtered = {read=FFiltered, write=SetFiltered, default=0};
  594.     __property TFilterOptions FilterOptions = {read=FFilterOptions, write=SetFilterOptions, default=0};
  595.         
  596.     __property bool Active = {read=GetActive, write=SetActive, default=0};
  597.     __property bool AutoCalcFields = {read=FAutoCalcFields, write=FAutoCalcFields, default=1};
  598.     __property TDataSetNotifyEvent BeforeOpen = {read=FBeforeOpen, write=FBeforeOpen};
  599.     __property TDataSetNotifyEvent AfterOpen = {read=FAfterOpen, write=FAfterOpen};
  600.     __property TDataSetNotifyEvent BeforeClose = {read=FBeforeClose, write=FBeforeClose};
  601.     __property TDataSetNotifyEvent AfterClose = {read=FAfterClose, write=FAfterClose};
  602.     __property TDataSetNotifyEvent BeforeInsert = {read=FBeforeInsert, write=FBeforeInsert};
  603.     __property TDataSetNotifyEvent AfterInsert = {read=FAfterInsert, write=FAfterInsert};
  604.     __property TDataSetNotifyEvent BeforeEdit = {read=FBeforeEdit, write=FBeforeEdit};
  605.     __property TDataSetNotifyEvent AfterEdit = {read=FAfterEdit, write=FAfterEdit};
  606.     __property TDataSetNotifyEvent BeforePost = {read=FBeforePost, write=FBeforePost};
  607.     __property TDataSetNotifyEvent AfterPost = {read=FAfterPost, write=FAfterPost};
  608.     __property TDataSetNotifyEvent BeforeCancel = {read=FBeforeCancel, write=FBeforeCancel};
  609.     __property TDataSetNotifyEvent AfterCancel = {read=FAfterCancel, write=FAfterCancel};
  610.     __property TDataSetNotifyEvent BeforeDelete = {read=FBeforeDelete, write=FBeforeDelete};
  611.     __property TDataSetNotifyEvent AfterDelete = {read=FAfterDelete, write=FAfterDelete};
  612.     __property TDataSetNotifyEvent BeforeScroll = {read=FBeforeScroll, write=FBeforeScroll};
  613.     __property TDataSetNotifyEvent AfterScroll = {read=FAfterScroll, write=FAfterScroll};
  614.     __property TDataSetNotifyEvent OnCalcFields = {read=FOnCalcFields, write=FOnCalcFields};
  615.     __property TDataSetErrorEvent OnDeleteError = {read=FOnDeleteError, write=FOnDeleteError};
  616.     __property TDataSetErrorEvent OnEditError = {read=FOnEditError, write=FOnEditError};
  617.     __property TFilterRecordEvent OnFilterRecord = {read=FOnFilterRecord, write=SetOnFilterRecord};
  618.     __property TDataSetNotifyEvent OnNewRecord = {read=FOnNewRecord, write=FOnNewRecord};
  619.     __property TDataSetErrorEvent OnPostError = {read=FOnPostError, write=FOnPostError};
  620. };
  621.  
  622.  
  623. class PASCALIMPLEMENTATION TFieldDef : public Db::TNamedItem 
  624. {
  625.     typedef Db::TNamedItem inherited;
  626.     
  627. private:
  628.     TFieldType FDataType;
  629.     int FPrecision;
  630.     Word FSize;
  631.     bool FRequired;
  632.     bool FInternalCalcField;
  633.     void __fastcall SetDataType(TFieldType AType);
  634.     System::TMetaClass* __fastcall GetFieldClass(void);
  635.     int __fastcall GetFieldNo(void);
  636.     void __fastcall SetFieldNo(int AFieldNo);
  637.     void __fastcall SetPrecision(int APrecision);
  638.     void __fastcall SetRequired(bool ARequired);
  639.     void __fastcall SetSize(Word ASize);
  640.     
  641. public:
  642.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  643.     TField* __fastcall CreateField(Classes::TComponent* Owner);
  644.     __property System::TMetaClass* FieldClass = {read=GetFieldClass};
  645.     __property bool InternalCalcField = {read=FInternalCalcField, write=FInternalCalcField, nodefault};
  646.         
  647.     
  648. __published:
  649.     __property int FieldNo = {read=GetFieldNo, write=SetFieldNo, stored=false, nodefault};
  650.     __property TFieldType DataType = {read=FDataType, write=SetDataType, nodefault};
  651.     __property int Precision = {read=FPrecision, write=SetPrecision, nodefault};
  652.     __property bool Required = {read=FRequired, write=SetRequired, nodefault};
  653.     __property Word Size = {read=FSize, write=SetSize, nodefault};
  654. public:
  655.     /* TCollectionItem.Create */ __fastcall virtual TFieldDef(Classes::TCollection* Collection) : Db::TNamedItem(
  656.         Collection) { }
  657.     /* TCollectionItem.Destroy */ __fastcall virtual ~TFieldDef(void) { }
  658.     
  659. };
  660.  
  661. enum Db__6 { ixPrimary, ixUnique, ixDescending, ixCaseInsensitive, ixExpression };
  662.  
  663. typedef Set<Db__6, ixPrimary, ixExpression>  TIndexOptions;
  664.  
  665. class DELPHICLASS TIndexDef;
  666. class PASCALIMPLEMENTATION TIndexDef : public Db::TNamedItem 
  667. {
  668.     typedef Db::TNamedItem inherited;
  669.     
  670. private:
  671.     System::AnsiString FSource;
  672.     System::AnsiString FFieldExpression;
  673.     TIndexOptions FOptions;
  674.     void __fastcall SetOptions(TIndexOptions AOptions);
  675.     void __fastcall SetSource(const System::AnsiString ASource);
  676.     System::AnsiString __fastcall GetExpression(void);
  677.     void __fastcall SetExpression(const System::AnsiString AExpression);
  678.     System::AnsiString __fastcall GetFields(void);
  679.     void __fastcall SetFields(const System::AnsiString AFields);
  680.     
  681. public:
  682.     virtual void __fastcall Assign(Classes::TPersistent* ASource);
  683.     __property System::AnsiString FieldExpression = {read=FFieldExpression};
  684.     
  685. __published:
  686.     __property TIndexOptions Options = {read=FOptions, write=SetOptions, nodefault};
  687.     __property System::AnsiString Expression = {read=GetExpression, write=SetExpression};
  688.     __property System::AnsiString Fields = {read=GetFields, write=SetFields};
  689.     __property System::AnsiString Source = {read=FSource, write=SetSource};
  690. public:
  691.     /* TCollectionItem.Create */ __fastcall virtual TIndexDef(Classes::TCollection* Collection) : Db::TNamedItem(
  692.         Collection) { }
  693.     /* TCollectionItem.Destroy */ __fastcall virtual ~TIndexDef(void) { }
  694.     
  695. };
  696.  
  697. class DELPHICLASS TIndexDefs;
  698. class PASCALIMPLEMENTATION TIndexDefs : public Db::TDefCollection 
  699. {
  700.     typedef Db::TDefCollection inherited;
  701.     
  702. private:
  703.     TIndexDef* __fastcall GetIndexDef(int Index);
  704.     void __fastcall SetIndexDef(int Index, TIndexDef* Value);
  705.     
  706. public:
  707.     __fastcall TIndexDefs(TDataSet* ADataset);
  708.     TIndexDef* __fastcall AddIndexDef(void);
  709.     HIDESBASE TIndexDef* __fastcall Find(const System::AnsiString Name);
  710.     HIDESBASE void __fastcall Update(void);
  711.     TIndexDef* __fastcall FindIndexForFields(const System::AnsiString Fields);
  712.     TIndexDef* __fastcall GetIndexForFields(const System::AnsiString Fields, bool CaseInsensitive);
  713.     HIDESBASE void __fastcall Add(const System::AnsiString N, const System::AnsiString F, TIndexOptions 
  714.         O);
  715.     __property TIndexDef* Items[int Index] = {read=GetIndexDef, write=SetIndexDef/*, default*/};
  716. public:
  717.         
  718.     /* TCollection.Destroy */ __fastcall virtual ~TIndexDefs(void) { }
  719.     
  720. };
  721.  
  722. enum TFieldKind { fkData, fkCalculated, fkLookup, fkInternalCalc };
  723.  
  724. typedef void __fastcall (__closure *TFieldNotifyEvent)(TField* Sender);
  725.  
  726. typedef void __fastcall (__closure *TFieldGetTextEvent)(TField* Sender, System::AnsiString &Text, bool 
  727.     DisplayText);
  728.  
  729. typedef void __fastcall (__closure *TFieldSetTextEvent)(TField* Sender, const System::AnsiString Text
  730.     );
  731.  
  732. typedef Set<char, 0, 255>  TFieldChars;
  733.  
  734. struct TLookupListEntry;
  735. typedef TLookupListEntry *PLookupListEntry;
  736.  
  737. struct TLookupListEntry
  738. {
  739.     System::Variant Key;
  740.     System::Variant Value;
  741. } ;
  742.  
  743. class DELPHICLASS TLookupList;
  744. class PASCALIMPLEMENTATION TLookupList : public System::TObject 
  745. {
  746.     typedef System::TObject inherited;
  747.     
  748. private:
  749.     Classes::TList* FList;
  750.     
  751. public:
  752.     __fastcall TLookupList(void);
  753.     __fastcall virtual ~TLookupList(void);
  754.     void __fastcall Add(const System::Variant &AKey, const System::Variant &AValue);
  755.     void __fastcall Clear(void);
  756.     System::Variant __fastcall ValueOfKey(const System::Variant &AKey);
  757. };
  758.  
  759. class PASCALIMPLEMENTATION TField : public Classes::TComponent 
  760. {
  761.     typedef Classes::TComponent inherited;
  762.     
  763. private:
  764.     TDataSet* FDataSet;
  765.     System::AnsiString FFieldName;
  766.     TFieldType FDataType;
  767.     bool FReadOnly;
  768.     TFieldKind FFieldKind;
  769.     TAlignment FAlignment;
  770.     bool FVisible;
  771.     bool FRequired;
  772.     bool FValidating;
  773.     Word FSize;
  774.     Word FOffset;
  775.     int FFieldNo;
  776.     int FDisplayWidth;
  777.     System::AnsiString FDisplayLabel;
  778.     System::AnsiString FEditMask;
  779.     void *FValueBuffer;
  780.     TDataSet* FLookupDataSet;
  781.     System::AnsiString FKeyFields;
  782.     System::AnsiString FLookupKeyFields;
  783.     System::AnsiString FLookupResultField;
  784.     bool FLookupCache;
  785.     TLookupList* FLookupList;
  786.     System::AnsiString FAttributeSet;
  787.     System::AnsiString FCustomConstraint;
  788.     System::AnsiString FImportedConstraint;
  789.     System::AnsiString FConstraintErrorMessage;
  790.     System::AnsiString FDefaultExpression;
  791.     System::AnsiString FOrigin;
  792.     TFieldChars FValidChars;
  793.     TFieldNotifyEvent FOnChange;
  794.     TFieldNotifyEvent FOnValidate;
  795.     TFieldGetTextEvent FOnGetText;
  796.     TFieldSetTextEvent FOnSetText;
  797.     void __fastcall Bind(bool Binding);
  798.     void __fastcall CalcLookupValue(void);
  799.     bool __fastcall FieldKindStored(void);
  800.     bool __fastcall GetCalculated(void);
  801.     System::AnsiString __fastcall GetDisplayLabel(void);
  802.     System::AnsiString __fastcall GetDisplayName(void);
  803.     System::AnsiString __fastcall GetDisplayText(void);
  804.     int __fastcall GetDisplayWidth(void);
  805.     System::AnsiString __fastcall GetEditText(void);
  806.     bool __fastcall GetHasConstraints(void);
  807.     int __fastcall GetIndex(void);
  808.     bool __fastcall GetIsIndexField(void);
  809.     bool __fastcall GetLookup(void);
  810.     TLookupList* __fastcall GetLookupList(void);
  811.     System::Variant __fastcall GetCurValue(void);
  812.     System::Variant __fastcall GetNewValue(void);
  813.     System::Variant __fastcall GetOldValue(void);
  814.     bool __fastcall IsDisplayLabelStored(void);
  815.     bool __fastcall IsDisplayWidthStored(void);
  816.     void __fastcall ReadAttributeSet(Classes::TReader* Reader);
  817.     void __fastcall ReadCalculated(Classes::TReader* Reader);
  818.     void __fastcall ReadLookup(Classes::TReader* Reader);
  819.     void __fastcall SetAlignment(Classes::TAlignment Value);
  820.     void __fastcall SetCalculated(bool Value);
  821.     void __fastcall SetDataSet(TDataSet* ADataSet);
  822.     void __fastcall SetDisplayLabel(System::AnsiString Value);
  823.     void __fastcall SetDisplayWidth(int Value);
  824.     void __fastcall SetEditMask(const System::AnsiString Value);
  825.     void __fastcall SetEditText(const System::AnsiString Value);
  826.     void __fastcall SetFieldKind(TFieldKind Value);
  827.     void __fastcall SetFieldName(const System::AnsiString Value);
  828.     void __fastcall SetIndex(int Value);
  829.     void __fastcall SetLookup(bool Value);
  830.     void __fastcall SetLookupDataSet(TDataSet* Value);
  831.     void __fastcall SetLookupKeyFields(const System::AnsiString Value);
  832.     void __fastcall SetLookupResultField(const System::AnsiString Value);
  833.     void __fastcall SetKeyFields(const System::AnsiString Value);
  834.     void __fastcall SetLookupCache(const bool Value);
  835.     void __fastcall SetNewValue(const System::Variant &Value);
  836.     void __fastcall SetReadOnly(const bool Value);
  837.     void __fastcall SetVisible(bool Value);
  838.     void __fastcall ValidateLookupInfo(bool All);
  839.     void __fastcall WriteAttributeSet(Classes::TWriter* Writer);
  840.     void __fastcall WriteCalculated(Classes::TWriter* Writer);
  841.     void __fastcall WriteLookup(Classes::TWriter* Writer);
  842.     
  843. protected:
  844.     DYNAMIC EDatabaseError* __fastcall AccessError(const System::AnsiString TypeName);
  845.     void __fastcall CheckInactive(void);
  846.     /* virtual class method */ virtual void __fastcall CheckTypeSize(int Value) { CheckTypeSize(__classid(TField)
  847.         , Value); }
  848.     /*         class method */ static void __fastcall CheckTypeSize(System::TMetaClass* vmt, int Value)
  849.         ;
  850.     virtual void __fastcall Change(void);
  851.     void __fastcall DataChanged(void);
  852.     virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
  853.     virtual void __fastcall FreeBuffers(void);
  854.     virtual bool __fastcall GetAsBoolean(void);
  855.     virtual System::Currency __fastcall GetAsCurrency(void);
  856.     virtual System::TDateTime __fastcall GetAsDateTime(void);
  857.     virtual double __fastcall GetAsFloat(void);
  858.     virtual int __fastcall GetAsInteger(void);
  859.     virtual System::AnsiString __fastcall GetAsString(void);
  860.     virtual System::Variant __fastcall GetAsVariant(void);
  861.     virtual bool __fastcall GetCanModify(void);
  862.     virtual Word __fastcall GetDataSize(void);
  863.     virtual int __fastcall GetDefaultWidth(void);
  864.     virtual bool __fastcall GetIsNull(void);
  865.     DYNAMIC Classes::TComponent* __fastcall GetParentComponent(void);
  866.     virtual void __fastcall GetText(System::AnsiString &Text, bool DisplayText);
  867.     DYNAMIC bool __fastcall HasParent(void);
  868.     virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
  869.         );
  870.     void __fastcall PropertyChanged(bool LayoutAffected);
  871.     virtual void __fastcall ReadState(Classes::TReader* Reader);
  872.     virtual void __fastcall SetAsBoolean(bool Value);
  873.     virtual void __fastcall SetAsCurrency(System::Currency Value);
  874.     virtual void __fastcall SetAsDateTime(System::TDateTime Value);
  875.     virtual void __fastcall SetAsFloat(double Value);
  876.     virtual void __fastcall SetAsInteger(int Value);
  877.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  878.     virtual void __fastcall SetAsVariant(const System::Variant &Value);
  879.     void __fastcall SetDataType(TFieldType Value);
  880.     virtual void __fastcall SetSize(Word Value);
  881.     DYNAMIC void __fastcall SetParentComponent(Classes::TComponent* AParent);
  882.     virtual void __fastcall SetText(const System::AnsiString Value);
  883.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  884.     
  885. public:
  886.     __fastcall virtual TField(Classes::TComponent* AOwner);
  887.     __fastcall virtual ~TField(void);
  888.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  889.     void __fastcall AssignValue(const System::TVarRec &Value);
  890.     virtual void __fastcall Clear(void);
  891.     void __fastcall FocusControl(void);
  892.     bool __fastcall GetData(void * Buffer);
  893.     /* virtual class method */ virtual bool __fastcall IsBlob() { IsBlob(__classid(TField)); }
  894.     /*         class method */ static bool __fastcall IsBlob(System::TMetaClass* vmt);
  895.     virtual bool __fastcall IsValidChar(char InputChar);
  896.     void __fastcall RefreshLookupList(void);
  897.     void __fastcall SetData(void * Buffer);
  898.     virtual void __fastcall SetFieldType(TFieldType Value);
  899.     void __fastcall Validate(void * Buffer);
  900.     __property bool AsBoolean = {read=GetAsBoolean, write=SetAsBoolean, nodefault};
  901.     __property System::Currency AsCurrency = {read=GetAsCurrency, write=SetAsCurrency};
  902.     __property System::TDateTime AsDateTime = {read=GetAsDateTime, write=SetAsDateTime};
  903.     __property double AsFloat = {read=GetAsFloat, write=SetAsFloat};
  904.     __property int AsInteger = {read=GetAsInteger, write=SetAsInteger, nodefault};
  905.     __property System::AnsiString AsString = {read=GetAsString, write=SetAsString};
  906.     __property System::Variant AsVariant = {read=GetAsVariant, write=SetAsVariant};
  907.     __property System::AnsiString AttributeSet = {read=FAttributeSet, write=FAttributeSet};
  908.     __property bool Calculated = {read=GetCalculated, write=SetCalculated, default=0};
  909.     __property bool CanModify = {read=GetCanModify, nodefault};
  910.     __property System::Variant CurValue = {read=GetCurValue};
  911.     __property TDataSet* DataSet = {read=FDataSet, write=SetDataSet, stored=false};
  912.     __property Word DataSize = {read=GetDataSize, nodefault};
  913.     __property TFieldType DataType = {read=FDataType, nodefault};
  914.     __property System::AnsiString DisplayName = {read=GetDisplayName};
  915.     __property System::AnsiString DisplayText = {read=GetDisplayText};
  916.     __property System::AnsiString EditMask = {read=FEditMask, write=SetEditMask};
  917.     __property System::AnsiString EditMaskPtr = {read=FEditMask};
  918.     __property int FieldNo = {read=FFieldNo, nodefault};
  919.     __property bool IsIndexField = {read=GetIsIndexField, nodefault};
  920.     __property bool IsNull = {read=GetIsNull, nodefault};
  921.     __property bool Lookup = {read=GetLookup, write=SetLookup, nodefault};
  922.     __property TLookupList* LookupList = {read=GetLookupList};
  923.     __property System::Variant NewValue = {read=GetNewValue, write=SetNewValue};
  924.     __property Word Offset = {read=FOffset, nodefault};
  925.     __property System::Variant OldValue = {read=GetOldValue};
  926.     __property Word Size = {read=FSize, write=SetSize, nodefault};
  927.     __property System::AnsiString Text = {read=GetEditText, write=SetEditText};
  928.     __property TFieldChars ValidChars = {read=FValidChars, write=FValidChars};
  929.     __property System::Variant Value = {read=GetAsVariant, write=SetAsVariant};
  930.     
  931. __published:
  932.     __property Classes::TAlignment Alignment = {read=FAlignment, write=SetAlignment, default=0};
  933.     __property System::AnsiString CustomConstraint = {read=FCustomConstraint, write=FCustomConstraint};
  934.         
  935.     __property System::AnsiString ConstraintErrorMessage = {read=FConstraintErrorMessage, write=FConstraintErrorMessage
  936.         };
  937.     __property System::AnsiString DefaultExpression = {read=FDefaultExpression, write=FDefaultExpression
  938.         };
  939.     __property System::AnsiString DisplayLabel = {read=GetDisplayLabel, write=SetDisplayLabel, stored=IsDisplayLabelStored
  940.         };
  941.     __property int DisplayWidth = {read=GetDisplayWidth, write=SetDisplayWidth, stored=IsDisplayWidthStored
  942.         , nodefault};
  943.     __property TFieldKind FieldKind = {read=FFieldKind, write=SetFieldKind, stored=FieldKindStored, nodefault
  944.         };
  945.     __property System::AnsiString FieldName = {read=FFieldName, write=SetFieldName};
  946.     __property bool HasConstraints = {read=GetHasConstraints, nodefault};
  947.     __property int Index = {read=GetIndex, write=SetIndex, stored=false, nodefault};
  948.     __property System::AnsiString ImportedConstraint = {read=FImportedConstraint, write=FImportedConstraint
  949.         };
  950.     __property TDataSet* LookupDataSet = {read=FLookupDataSet, write=SetLookupDataSet};
  951.     __property System::AnsiString LookupKeyFields = {read=FLookupKeyFields, write=SetLookupKeyFields};
  952.     __property System::AnsiString LookupResultField = {read=FLookupResultField, write=SetLookupResultField
  953.         };
  954.     __property System::AnsiString KeyFields = {read=FKeyFields, write=SetKeyFields};
  955.     __property bool LookupCache = {read=FLookupCache, write=SetLookupCache, default=0};
  956.     __property System::AnsiString Origin = {read=FOrigin, write=FOrigin};
  957.     __property bool ReadOnly = {read=FReadOnly, write=SetReadOnly, default=0};
  958.     __property bool Required = {read=FRequired, write=FRequired, default=0};
  959.     __property bool Visible = {read=FVisible, write=SetVisible, default=1};
  960.     __property TFieldNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
  961.     __property TFieldGetTextEvent OnGetText = {read=FOnGetText, write=FOnGetText};
  962.     __property TFieldSetTextEvent OnSetText = {read=FOnSetText, write=FOnSetText};
  963.     __property TFieldNotifyEvent OnValidate = {read=FOnValidate, write=FOnValidate};
  964. };
  965.  
  966. class DELPHICLASS TStringField;
  967. class PASCALIMPLEMENTATION TStringField : public Db::TField 
  968. {
  969.     typedef Db::TField inherited;
  970.     
  971. private:
  972.     bool FTransliterate;
  973.     
  974. protected:
  975.     /* virtual class method */ virtual void __fastcall CheckTypeSize(int Value) { CheckTypeSize(__classid(TStringField)
  976.         , Value); }
  977.     /*         class method */ static void __fastcall CheckTypeSize(System::TMetaClass* vmt, int Value)
  978.         ;
  979.     virtual bool __fastcall GetAsBoolean(void);
  980.     virtual System::TDateTime __fastcall GetAsDateTime(void);
  981.     virtual double __fastcall GetAsFloat(void);
  982.     virtual int __fastcall GetAsInteger(void);
  983.     virtual System::AnsiString __fastcall GetAsString(void);
  984.     virtual System::Variant __fastcall GetAsVariant(void);
  985.     virtual Word __fastcall GetDataSize(void);
  986.     virtual int __fastcall GetDefaultWidth(void);
  987.     virtual void __fastcall GetText(System::AnsiString &Text, bool DisplayText);
  988.     bool __fastcall GetValue(System::AnsiString &Value);
  989.     virtual void __fastcall SetAsBoolean(bool Value);
  990.     virtual void __fastcall SetAsDateTime(System::TDateTime Value);
  991.     virtual void __fastcall SetAsFloat(double Value);
  992.     virtual void __fastcall SetAsInteger(int Value);
  993.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  994.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  995.     
  996. public:
  997.     __fastcall virtual TStringField(Classes::TComponent* AOwner);
  998.     __property System::AnsiString Value = {read=GetAsString, write=SetAsString};
  999.     
  1000. __published:
  1001.     __property EditMask ;
  1002.     __property Size ;
  1003.     __property bool Transliterate = {read=FTransliterate, write=FTransliterate, default=1};
  1004. public:
  1005.     /* TField.Destroy */ __fastcall virtual ~TStringField(void) { }
  1006.     
  1007. };
  1008.  
  1009. class DELPHICLASS TNumericField;
  1010. class PASCALIMPLEMENTATION TNumericField : public Db::TField 
  1011. {
  1012.     typedef Db::TField inherited;
  1013.     
  1014. private:
  1015.     System::AnsiString FDisplayFormat;
  1016.     System::AnsiString FEditFormat;
  1017.     
  1018. protected:
  1019.     void __fastcall RangeError(Extended Value, Extended Min, Extended Max);
  1020.     void __fastcall SetDisplayFormat(const System::AnsiString Value);
  1021.     void __fastcall SetEditFormat(const System::AnsiString Value);
  1022.     
  1023. public:
  1024.     __fastcall virtual TNumericField(Classes::TComponent* AOwner);
  1025.     
  1026. __published:
  1027.     __property Alignment ;
  1028.     __property System::AnsiString DisplayFormat = {read=FDisplayFormat, write=SetDisplayFormat};
  1029.     __property System::AnsiString EditFormat = {read=FEditFormat, write=SetEditFormat};
  1030. public:
  1031.     /* TField.Destroy */ __fastcall virtual ~TNumericField(void) { }
  1032.     
  1033. };
  1034.  
  1035. class DELPHICLASS TIntegerField;
  1036. class PASCALIMPLEMENTATION TIntegerField : public Db::TNumericField 
  1037. {
  1038.     typedef Db::TNumericField inherited;
  1039.     
  1040. private:
  1041.     int FMinRange;
  1042.     int FMaxRange;
  1043.     int FMinValue;
  1044.     int FMaxValue;
  1045.     void __fastcall CheckRange(int Value, int Min, int Max);
  1046.     void __fastcall SetMaxValue(int Value);
  1047.     void __fastcall SetMinValue(int Value);
  1048.     
  1049. protected:
  1050.     virtual double __fastcall GetAsFloat(void);
  1051.     virtual int __fastcall GetAsInteger(void);
  1052.     virtual System::AnsiString __fastcall GetAsString(void);
  1053.     virtual System::Variant __fastcall GetAsVariant(void);
  1054.     virtual Word __fastcall GetDataSize(void);
  1055.     virtual void __fastcall GetText(System::AnsiString &Text, bool DisplayText);
  1056.     bool __fastcall GetValue(int &Value);
  1057.     virtual void __fastcall SetAsFloat(double Value);
  1058.     virtual void __fastcall SetAsInteger(int Value);
  1059.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  1060.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  1061.     
  1062. public:
  1063.     __fastcall virtual TIntegerField(Classes::TComponent* AOwner);
  1064.     __property int Value = {read=GetAsInteger, write=SetAsInteger, nodefault};
  1065.     
  1066. __published:
  1067.     __property int MaxValue = {read=FMaxValue, write=SetMaxValue, default=0};
  1068.     __property int MinValue = {read=FMinValue, write=SetMinValue, default=0};
  1069. public:
  1070.     /* TField.Destroy */ __fastcall virtual ~TIntegerField(void) { }
  1071.     
  1072. };
  1073.  
  1074. class DELPHICLASS TSmallintField;
  1075. class PASCALIMPLEMENTATION TSmallintField : public Db::TIntegerField 
  1076. {
  1077.     typedef Db::TIntegerField inherited;
  1078.     
  1079. protected:
  1080.     virtual Word __fastcall GetDataSize(void);
  1081.     
  1082. public:
  1083.     __fastcall virtual TSmallintField(Classes::TComponent* AOwner);
  1084. public:
  1085.     /* TField.Destroy */ __fastcall virtual ~TSmallintField(void) { }
  1086.     
  1087. };
  1088.  
  1089. class DELPHICLASS TWordField;
  1090. class PASCALIMPLEMENTATION TWordField : public Db::TIntegerField 
  1091. {
  1092.     typedef Db::TIntegerField inherited;
  1093.     
  1094. protected:
  1095.     virtual Word __fastcall GetDataSize(void);
  1096.     
  1097. public:
  1098.     __fastcall virtual TWordField(Classes::TComponent* AOwner);
  1099. public:
  1100.     /* TField.Destroy */ __fastcall virtual ~TWordField(void) { }
  1101.     
  1102. };
  1103.  
  1104. class DELPHICLASS TAutoIncField;
  1105. class PASCALIMPLEMENTATION TAutoIncField : public Db::TIntegerField 
  1106. {
  1107.     typedef Db::TIntegerField inherited;
  1108.     
  1109. public:
  1110.     __fastcall virtual TAutoIncField(Classes::TComponent* AOwner);
  1111. public:
  1112.     /* TField.Destroy */ __fastcall virtual ~TAutoIncField(void) { }
  1113.     
  1114. };
  1115.  
  1116. class DELPHICLASS TFloatField;
  1117. class PASCALIMPLEMENTATION TFloatField : public Db::TNumericField 
  1118. {
  1119.     typedef Db::TNumericField inherited;
  1120.     
  1121. private:
  1122.     bool FCurrency;
  1123.     bool FCheckRange;
  1124.     int FPrecision;
  1125.     double FMinValue;
  1126.     double FMaxValue;
  1127.     void __fastcall SetCurrency(bool Value);
  1128.     void __fastcall SetMaxValue(double Value);
  1129.     void __fastcall SetMinValue(double Value);
  1130.     void __fastcall SetPrecision(int Value);
  1131.     void __fastcall UpdateCheckRange(void);
  1132.     
  1133. protected:
  1134.     virtual double __fastcall GetAsFloat(void);
  1135.     virtual int __fastcall GetAsInteger(void);
  1136.     virtual System::AnsiString __fastcall GetAsString(void);
  1137.     virtual System::Variant __fastcall GetAsVariant(void);
  1138.     virtual Word __fastcall GetDataSize(void);
  1139.     virtual void __fastcall GetText(System::AnsiString &Text, bool DisplayText);
  1140.     virtual void __fastcall SetAsFloat(double Value);
  1141.     virtual void __fastcall SetAsInteger(int Value);
  1142.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  1143.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  1144.     
  1145. public:
  1146.     __fastcall virtual TFloatField(Classes::TComponent* AOwner);
  1147.     __property double Value = {read=GetAsFloat, write=SetAsFloat};
  1148.     
  1149. __published:
  1150.     __property bool currency = {read=FCurrency, write=SetCurrency, default=0};
  1151.     __property double MaxValue = {read=FMaxValue, write=SetMaxValue};
  1152.     __property double MinValue = {read=FMinValue, write=SetMinValue};
  1153.     __property int Precision = {read=FPrecision, write=SetPrecision, default=15};
  1154. public:
  1155.     /* TField.Destroy */ __fastcall virtual ~TFloatField(void) { }
  1156.     
  1157. };
  1158.  
  1159. class DELPHICLASS TCurrencyField;
  1160. class PASCALIMPLEMENTATION TCurrencyField : public Db::TFloatField 
  1161. {
  1162.     typedef Db::TFloatField inherited;
  1163.     
  1164. public:
  1165.     __fastcall virtual TCurrencyField(Classes::TComponent* AOwner);
  1166.     
  1167. __published:
  1168.     __property Currency ;
  1169. public:
  1170.     /* TField.Destroy */ __fastcall virtual ~TCurrencyField(void) { }
  1171.     
  1172. };
  1173.  
  1174. typedef System::AnsiString Db__02[2];
  1175.  
  1176. class DELPHICLASS TBooleanField;
  1177. class PASCALIMPLEMENTATION TBooleanField : public Db::TField 
  1178. {
  1179.     typedef Db::TField inherited;
  1180.     
  1181. private:
  1182.     System::AnsiString FDisplayValues;
  1183.     System::AnsiString FTextValues[2];
  1184.     void __fastcall LoadTextValues(void);
  1185.     void __fastcall SetDisplayValues(const System::AnsiString Value);
  1186.     
  1187. protected:
  1188.     virtual bool __fastcall GetAsBoolean(void);
  1189.     virtual System::AnsiString __fastcall GetAsString(void);
  1190.     virtual System::Variant __fastcall GetAsVariant(void);
  1191.     virtual Word __fastcall GetDataSize(void);
  1192.     virtual int __fastcall GetDefaultWidth(void);
  1193.     virtual void __fastcall SetAsBoolean(bool Value);
  1194.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  1195.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  1196.     
  1197. public:
  1198.     __fastcall virtual TBooleanField(Classes::TComponent* AOwner);
  1199.     __property bool Value = {read=GetAsBoolean, write=SetAsBoolean, nodefault};
  1200.     
  1201. __published:
  1202.     __property System::AnsiString DisplayValues = {read=FDisplayValues, write=SetDisplayValues};
  1203. public:
  1204.         
  1205.     /* TField.Destroy */ __fastcall virtual ~TBooleanField(void) { }
  1206.     
  1207. };
  1208.  
  1209. class DELPHICLASS TDateTimeField;
  1210. class PASCALIMPLEMENTATION TDateTimeField : public Db::TField 
  1211. {
  1212.     typedef Db::TField inherited;
  1213.     
  1214. private:
  1215.     System::AnsiString FDisplayFormat;
  1216.     bool __fastcall GetValue(System::TDateTime &Value);
  1217.     void __fastcall SetDisplayFormat(const System::AnsiString Value);
  1218.     
  1219. protected:
  1220.     virtual System::TDateTime __fastcall GetAsDateTime(void);
  1221.     virtual double __fastcall GetAsFloat(void);
  1222.     virtual System::AnsiString __fastcall GetAsString(void);
  1223.     virtual System::Variant __fastcall GetAsVariant(void);
  1224.     virtual Word __fastcall GetDataSize(void);
  1225.     virtual void __fastcall GetText(System::AnsiString &Text, bool DisplayText);
  1226.     virtual void __fastcall SetAsDateTime(System::TDateTime Value);
  1227.     virtual void __fastcall SetAsFloat(double Value);
  1228.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  1229.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  1230.     
  1231. public:
  1232.     __fastcall virtual TDateTimeField(Classes::TComponent* AOwner);
  1233.     __property System::TDateTime Value = {read=GetAsDateTime, write=SetAsDateTime};
  1234.     
  1235. __published:
  1236.     __property System::AnsiString DisplayFormat = {read=FDisplayFormat, write=SetDisplayFormat};
  1237.     __property EditMask ;
  1238. public:
  1239.     /* TField.Destroy */ __fastcall virtual ~TDateTimeField(void) { }
  1240.     
  1241. };
  1242.  
  1243. class DELPHICLASS TDateField;
  1244. class PASCALIMPLEMENTATION TDateField : public Db::TDateTimeField 
  1245. {
  1246.     typedef Db::TDateTimeField inherited;
  1247.     
  1248. protected:
  1249.     virtual Word __fastcall GetDataSize(void);
  1250.     
  1251. public:
  1252.     __fastcall virtual TDateField(Classes::TComponent* AOwner);
  1253. public:
  1254.     /* TField.Destroy */ __fastcall virtual ~TDateField(void) { }
  1255.     
  1256. };
  1257.  
  1258. class DELPHICLASS TTimeField;
  1259. class PASCALIMPLEMENTATION TTimeField : public Db::TDateTimeField 
  1260. {
  1261.     typedef Db::TDateTimeField inherited;
  1262.     
  1263. protected:
  1264.     virtual Word __fastcall GetDataSize(void);
  1265.     
  1266. public:
  1267.     __fastcall virtual TTimeField(Classes::TComponent* AOwner);
  1268. public:
  1269.     /* TField.Destroy */ __fastcall virtual ~TTimeField(void) { }
  1270.     
  1271. };
  1272.  
  1273. class DELPHICLASS TBinaryField;
  1274. class PASCALIMPLEMENTATION TBinaryField : public Db::TField 
  1275. {
  1276.     typedef Db::TField inherited;
  1277.     
  1278. protected:
  1279.     /* virtual class method */ virtual void __fastcall CheckTypeSize(int Value) { CheckTypeSize(__classid(TBinaryField)
  1280.         , Value); }
  1281.     /*         class method */ static void __fastcall CheckTypeSize(System::TMetaClass* vmt, int Value)
  1282.         ;
  1283.     virtual System::AnsiString __fastcall GetAsString(void);
  1284.     virtual void __fastcall GetText(System::AnsiString &Text, bool DisplayText);
  1285.     virtual System::Variant __fastcall GetAsVariant(void);
  1286.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  1287.     virtual void __fastcall SetText(const System::AnsiString Value);
  1288.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  1289.     
  1290. public:
  1291.     __fastcall virtual TBinaryField(Classes::TComponent* AOwner);
  1292.     
  1293. __published:
  1294.     __property Size ;
  1295. public:
  1296.     /* TField.Destroy */ __fastcall virtual ~TBinaryField(void) { }
  1297.     
  1298. };
  1299.  
  1300. class DELPHICLASS TBytesField;
  1301. class PASCALIMPLEMENTATION TBytesField : public Db::TBinaryField 
  1302. {
  1303.     typedef Db::TBinaryField inherited;
  1304.     
  1305. protected:
  1306.     virtual Word __fastcall GetDataSize(void);
  1307.     
  1308. public:
  1309.     __fastcall virtual TBytesField(Classes::TComponent* AOwner);
  1310. public:
  1311.     /* TField.Destroy */ __fastcall virtual ~TBytesField(void) { }
  1312.     
  1313. };
  1314.  
  1315. class DELPHICLASS TVarBytesField;
  1316. class PASCALIMPLEMENTATION TVarBytesField : public Db::TBytesField 
  1317. {
  1318.     typedef Db::TBytesField inherited;
  1319.     
  1320. protected:
  1321.     virtual Word __fastcall GetDataSize(void);
  1322.     
  1323. public:
  1324.     __fastcall virtual TVarBytesField(Classes::TComponent* AOwner);
  1325. public:
  1326.     /* TField.Destroy */ __fastcall virtual ~TVarBytesField(void) { }
  1327.     
  1328. };
  1329.  
  1330. class DELPHICLASS TBCDField;
  1331. class PASCALIMPLEMENTATION TBCDField : public Db::TNumericField 
  1332. {
  1333.     typedef Db::TNumericField inherited;
  1334.     
  1335. private:
  1336.     bool FCurrency;
  1337.     bool FCheckRange;
  1338.     System::Currency FMinValue;
  1339.     System::Currency FMaxValue;
  1340.     int FPrecision;
  1341.     void __fastcall SetCurrency(bool Value);
  1342.     void __fastcall SetMaxValue(System::Currency Value);
  1343.     void __fastcall SetMinValue(System::Currency Value);
  1344.     void __fastcall UpdateCheckRange(void);
  1345.     
  1346. protected:
  1347.     /* virtual class method */ virtual void __fastcall CheckTypeSize(int Value) { CheckTypeSize(__classid(TBCDField)
  1348.         , Value); }
  1349.     /*         class method */ static void __fastcall CheckTypeSize(System::TMetaClass* vmt, int Value)
  1350.         ;
  1351.     virtual System::Currency __fastcall GetAsCurrency(void);
  1352.     virtual double __fastcall GetAsFloat(void);
  1353.     virtual int __fastcall GetAsInteger(void);
  1354.     virtual System::AnsiString __fastcall GetAsString(void);
  1355.     virtual System::Variant __fastcall GetAsVariant(void);
  1356.     virtual Word __fastcall GetDataSize(void);
  1357.     virtual int __fastcall GetDefaultWidth(void);
  1358.     virtual void __fastcall GetText(System::AnsiString &Text, bool DisplayText);
  1359.     bool __fastcall GetValue(System::Currency &Value);
  1360.     virtual void __fastcall SetAsCurrency(System::Currency Value);
  1361.     virtual void __fastcall SetAsFloat(double Value);
  1362.     virtual void __fastcall SetAsInteger(int Value);
  1363.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  1364.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  1365.     
  1366. public:
  1367.     __fastcall virtual TBCDField(Classes::TComponent* AOwner);
  1368.     __property System::Currency Value = {read=GetAsCurrency, write=SetAsCurrency};
  1369.     
  1370. __published:
  1371.     __property bool currency = {read=FCurrency, write=SetCurrency, default=0};
  1372.     __property System::Currency MaxValue = {read=FMaxValue, write=SetMaxValue};
  1373.     __property System::Currency MinValue = {read=FMinValue, write=SetMinValue};
  1374.     __property Size ;
  1375. public:
  1376.     /* TField.Destroy */ __fastcall virtual ~TBCDField(void) { }
  1377.     
  1378. };
  1379.  
  1380. typedef TFieldType TBlobType;
  1381.  
  1382. class DELPHICLASS TBlobField;
  1383. class PASCALIMPLEMENTATION TBlobField : public Db::TField 
  1384. {
  1385.     typedef Db::TField inherited;
  1386.     
  1387. private:
  1388.     bool FModified;
  1389.     int FModifiedRecord;
  1390.     bool FTransliterate;
  1391.     TBlobType __fastcall GetBlobType(void);
  1392.     bool __fastcall GetModified(void);
  1393.     void __fastcall LoadFromBlob(TBlobField* Blob);
  1394.     void __fastcall LoadFromBitmap(Graphics::TBitmap* Bitmap);
  1395.     void __fastcall LoadFromStrings(Classes::TStrings* Strings);
  1396.     void __fastcall SaveToBitmap(Graphics::TBitmap* Bitmap);
  1397.     void __fastcall SaveToStrings(Classes::TStrings* Strings);
  1398.     void __fastcall SetBlobType(TBlobType Value);
  1399.     void __fastcall SetModified(bool Value);
  1400.     
  1401. protected:
  1402.     virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
  1403.     virtual void __fastcall FreeBuffers(void);
  1404.     virtual System::AnsiString __fastcall GetAsString(void);
  1405.     virtual System::Variant __fastcall GetAsVariant(void);
  1406.     virtual int __fastcall GetBlobSize(void);
  1407.     virtual bool __fastcall GetIsNull(void);
  1408.     virtual void __fastcall GetText(System::AnsiString &Text, bool DisplayText);
  1409.     virtual void __fastcall SetAsString(const System::AnsiString Value);
  1410.     virtual void __fastcall SetText(const System::AnsiString Value);
  1411.     virtual void __fastcall SetVarValue(const System::Variant &Value);
  1412.     
  1413. public:
  1414.     __fastcall virtual TBlobField(Classes::TComponent* AOwner);
  1415.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  1416.     virtual void __fastcall Clear(void);
  1417.     /* virtual class method */ virtual bool __fastcall IsBlob() { IsBlob(__classid(TBlobField)); }
  1418.     /*         class method */ static bool __fastcall IsBlob(System::TMetaClass* vmt);
  1419.     void __fastcall LoadFromFile(const System::AnsiString FileName);
  1420.     void __fastcall LoadFromStream(Classes::TStream* Stream);
  1421.     void __fastcall SaveToFile(const System::AnsiString FileName);
  1422.     void __fastcall SaveToStream(Classes::TStream* Stream);
  1423.     virtual void __fastcall SetFieldType(TFieldType Value);
  1424.     __property int BlobSize = {read=GetBlobSize, nodefault};
  1425.     __property bool Modified = {read=GetModified, write=SetModified, nodefault};
  1426.     __property System::AnsiString Value = {read=GetAsString, write=SetAsString};
  1427.     __property bool Transliterate = {read=FTransliterate, write=FTransliterate, nodefault};
  1428.     
  1429. __published:
  1430.     __property TBlobType BlobType = {read=GetBlobType, write=SetBlobType, nodefault};
  1431.     __property Size ;
  1432. public:
  1433.     /* TField.Destroy */ __fastcall virtual ~TBlobField(void) { }
  1434.     
  1435. };
  1436.  
  1437. class DELPHICLASS TMemoField;
  1438. class PASCALIMPLEMENTATION TMemoField : public Db::TBlobField 
  1439. {
  1440.     typedef Db::TBlobField inherited;
  1441.     
  1442. public:
  1443.     __fastcall virtual TMemoField(Classes::TComponent* AOwner);
  1444.     
  1445. __published:
  1446.     __property Transliterate ;
  1447. public:
  1448.     /* TField.Destroy */ __fastcall virtual ~TMemoField(void) { }
  1449.     
  1450. };
  1451.  
  1452. class DELPHICLASS TGraphicField;
  1453. class PASCALIMPLEMENTATION TGraphicField : public Db::TBlobField 
  1454. {
  1455.     typedef Db::TBlobField inherited;
  1456.     
  1457. public:
  1458.     __fastcall virtual TGraphicField(Classes::TComponent* AOwner);
  1459. public:
  1460.     /* TField.Destroy */ __fastcall virtual ~TGraphicField(void) { }
  1461.     
  1462. };
  1463.  
  1464. class PASCALIMPLEMENTATION TCheckConstraint : public Classes::TCollectionItem 
  1465. {
  1466.     typedef Classes::TCollectionItem inherited;
  1467.     
  1468. private:
  1469.     System::AnsiString FImportedConstraint;
  1470.     System::AnsiString FCustomConstraint;
  1471.     System::AnsiString FErrorMessage;
  1472.     bool FFromDictionary;
  1473.     void __fastcall SetImportedConstraint(const System::AnsiString Value);
  1474.     void __fastcall SetCustomConstraint(const System::AnsiString Value);
  1475.     void __fastcall SetErrorMessage(const System::AnsiString Value);
  1476.     
  1477. public:
  1478.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  1479.     virtual System::AnsiString __fastcall GetDisplayName(void);
  1480.     
  1481. __published:
  1482.     __property System::AnsiString CustomConstraint = {read=FCustomConstraint, write=SetCustomConstraint
  1483.         };
  1484.     __property System::AnsiString ErrorMessage = {read=FErrorMessage, write=SetErrorMessage};
  1485.     __property bool FromDictionary = {read=FFromDictionary, write=FFromDictionary, nodefault};
  1486.     __property System::AnsiString ImportedConstraint = {read=FImportedConstraint, write=SetImportedConstraint
  1487.         };
  1488. public:
  1489.     /* TCollectionItem.Create */ __fastcall virtual TCheckConstraint(Classes::TCollection* Collection) : 
  1490.         Classes::TCollectionItem(Collection) { }
  1491.     /* TCollectionItem.Destroy */ __fastcall virtual ~TCheckConstraint(void) { }
  1492.     
  1493. };
  1494.  
  1495. typedef void *TBookmark;
  1496.  
  1497. typedef System::AnsiString TBookmarkStr;
  1498.  
  1499. typedef TBookmarkFlag *PBookmarkFlag;
  1500.  
  1501. enum TUpdateKind { ukModify, ukInsert, ukDelete };
  1502.  
  1503. struct TDateTimeRec
  1504. {
  1505.     
  1506.     union
  1507.     {
  1508.         TDateTimeAlias DateTime;
  1509.         int Time;
  1510.         int Date;
  1511.         
  1512.     };
  1513. } ;
  1514.  
  1515. //-- var, const, procedure ---------------------------------------------------
  1516. #define dsMaxBufferCount (int)(268435455)
  1517. #define dsMaxStringSize (Word)(8192)
  1518. #define dsEditModes (System::Set<TDataSetState, dsInactive, dsCurValue> () << dsEdit << dsInsert << dsSetKey \
  1519.     )
  1520. #define dsWriteModes (System::Set<TDataSetState, dsInactive, dsCurValue> () << dsEdit << dsInsert << dsSetKey \
  1521.     << dsCalcFields << dsFilter << dsNewValue )
  1522. extern PACKAGE System::TMetaClass*DefaultFieldClasses[22];
  1523. extern PACKAGE void __fastcall (*RegisterFieldsProc)(System::TMetaClass* const * FieldClassess, const 
  1524.     int FieldClassess_Size);
  1525. extern PACKAGE void __fastcall DatabaseError(const System::AnsiString Message);
  1526. extern PACKAGE void __fastcall DatabaseErrorFmt(const System::AnsiString Message, const System::TVarRec 
  1527.     * Args, const int Args_Size);
  1528. extern PACKAGE void __fastcall DBError(Word Ident);
  1529. extern PACKAGE void __fastcall DBErrorFmt(Word Ident, const System::TVarRec * Args, const int Args_Size
  1530.     );
  1531. extern PACKAGE TField* __fastcall GetFieldProperty(TDataSet* DataSet, Classes::TComponent* Control, 
  1532.     const System::AnsiString FieldName);
  1533. extern PACKAGE void __fastcall DisposeMem(void *Buffer, int Size);
  1534. extern PACKAGE bool __fastcall BuffersEqual(void * Buf1, void * Buf2, int Size);
  1535. extern PACKAGE System::AnsiString __fastcall ExtractFieldName(const System::AnsiString Fields, int &
  1536.     Pos);
  1537. extern PACKAGE void __fastcall RegisterFields(System::TMetaClass* const * FieldClasses, const int FieldClasses_Size
  1538.     );
  1539.  
  1540. }    /* namespace Db */
  1541. #if !defined(NO_IMPLICIT_NAMESPACE_USE)
  1542. using namespace Db;
  1543. #endif
  1544. //-- end unit ----------------------------------------------------------------
  1545. #endif    // Db
  1546.